﻿<!DOCTYPE html>
<html class="theme theme-white">
<head>
<meta charset="utf-8">
<title>基础知识</title>
<link href="https://www.zybuluo.com/static/assets/template-theme-white.css" rel="stylesheet" media="screen">
<style type="text/css">

#wmd-preview h1  {
    color: #0077bb; /* 将标题改为蓝色 */
}</style>
</head>
<body class="theme theme-white">
<div id="wmd-preview" class="wmd-preview wmd-preview-full-reader"><div class="md-section-divider"></div><div class="md-section-divider"></div><h1 data-anchor-id="wz8a" id="基础知识">基础知识</h1><p data-anchor-id="nirm"><code>Java面试题</code> <code>相关概念</code></p><hr><div class="md-section-divider"></div><h3 data-anchor-id="2yk7" id="对象是什么">对象是什么？</h3><p data-anchor-id="jdu5">对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。</p><p data-anchor-id="z7lw">类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。</p><p data-anchor-id="032h">当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。</p><div class="md-section-divider"></div><h3 data-anchor-id="8usr" id="什么是类">什么是类？</h3><p data-anchor-id="15mv">类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。</p><p data-anchor-id="ipk4">Java中的类实现包括两个部分：类声明和类体。</p><div class="md-section-divider"></div><h3 data-anchor-id="2nux" id="面向对象的特征有哪些方面">面向对象的特征有哪些方面？</h3><p data-anchor-id="eqja">面向对象的特征主要有以下几个方面： </p><ul data-anchor-id="519b">
<li><p>抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 </p></li>
<li><p>继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分）。 </p></li>
<li><p>封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。 </p></li>
<li><p>多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：</p>

<ul><li>1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；</li>
<li>2). 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。</li></ul></li>
</ul><div class="md-section-divider"></div><h3 data-anchor-id="fn9g" id="面向对象软件开发的优点有哪些">面向对象软件开发的优点有哪些？</h3><p data-anchor-id="inzm">代码开发模块化，更易维护和修改。 <br>
代码复用。 <br>
增强代码的可靠性和灵活性。 <br>
增加代码的可理解性。 <br>
面向对象编程有很多重要的特性，比如：封装，继承，多态和抽象。</p><div class="md-section-divider"></div><h3 data-anchor-id="cwkg" id="封装的定义和好处有哪些">封装的定义和好处有哪些？</h3><p data-anchor-id="qpsi">封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在Java当中，有3种修饰符：public，private和protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。 <br>
下面列出了使用封装的一些好处： <br>
通过隐藏对象的属性来保护对象内部的状态。 <br>
提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。 <br>
禁止对象之间的不良交互提高模块化。 <br>
参考这个文档获取更多关于封装的细节和示例。</p><div class="md-section-divider"></div><h3 data-anchor-id="u35b" id="和的区别">&amp;和&amp;&amp;的区别？</h3><p data-anchor-id="6rok">&amp;运算符有两种用法：(1)按位与；(2)逻辑与。&amp;&amp;运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&amp;&amp;之所以称为短路运算是因为，如果&amp;&amp;左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&amp;&amp;而不是&amp;，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &amp;&amp;!username.equals("")，二者的顺序不能交换，更不能用&amp;运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。</p><div class="md-section-divider"></div><h3 data-anchor-id="jyrf" id="封装类-pojo-entity实体类-javabean">封装类 &lt; POJO ≈ entity实体类 &lt; JavaBean</h3><div class="md-section-divider"></div><h4 data-anchor-id="izi7" id="封装类">封装类</h4><p data-anchor-id="97zk">将类的变量声明为 private ，提供公共 setter 和 getter 方法以修改和查看变量值。</p><div class="md-section-divider"></div><h4 data-anchor-id="1fz0" id="pojo">POJO</h4><p data-anchor-id="2rzx">Plain Old Java Object 的缩写，可以理解为简单的 JavaBean 。 POJO 实质上可以理解为简单的实体类，顾名思义 POJO 类的作用是方便程序员使用数据库中的数据表，对于广大的程序员，可以很方便的将 POJO 类当做对象来进行使用，当然也是可以方便的调用其 getter , setter 方法。</p><div class="md-section-divider"></div><h4 data-anchor-id="2bv5" id="entity-实体类">entity 实体类</h4><p data-anchor-id="phjb">就是属性类，通常定义在 model 层里面。一般的实体类对应一个数据表，其中的属性对应数据表中的字段。实体类就是一个拥有 getter 和 setter 方法的类。 entity （实体类）的作用一般是和数据表做映射。实体类通常总是和数据库之类的（所谓持久层数据）联系在一起。介于 dao 和 service 之间。</p><div class="md-section-divider"></div><h4 data-anchor-id="fy4w" id="javabean">JavaBean</h4><p data-anchor-id="nu38">是遵循 Sun 定义的 JavaBeans 约定的类。 <br>
JavaBeans是 Java 中一种特殊的类，可以将多个对象封装到一个对象（bean）中。特点是可序列化，提供无参构造器，提供 getter 方法和 setter 方法访问对象的属性。</p><p data-anchor-id="w0rp">如果一个Java类的每个实例变量都被 private 修饰，并为每个实例变量提供了 public 修饰的 setter 和 getter 方法，那么这个类是符合 JavaBean 规范的类。因此， JavaBean 总是一个封装良好的类。</p><div class="md-section-divider"></div><h3 data-anchor-id="up0m" id="多态的好处">多态的好处</h3><p data-anchor-id="9ejo">多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。</p><p data-anchor-id="y99c">主要有以下优点:</p><ul data-anchor-id="6kou">
<li>可替换性:多态对已存在代码具有可替换性.</li>
<li>可扩充性:增加新的子类不影响已经存在的类结构.</li>
<li>接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的.</li>
<li>灵活性:它在应用中体现了灵活多样的操作，提高了使用效率</li>
<li>简化性:多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要</li>
</ul><div class="md-section-divider"></div><h3 data-anchor-id="us9b" id="代码中如何实现多态">代码中如何实现多态</h3><p data-anchor-id="tw2g">实现多态主要有以下三种方式:  <br>
1. 接口实现  <br>
2. 继承父类重写方法  <br>
3. 同一类中进行方法重载</p><div class="md-section-divider"></div><h3 data-anchor-id="o8kd" id="虚拟机是如何实现多态的">虚拟机是如何实现多态的</h3><p data-anchor-id="sqpd">动态绑定技术(dynamic binding),执行期间判断所引用对象的实际类型,根据实际类型调用对应的方法.</p><div class="md-section-divider"></div><h3 data-anchor-id="0426" id="在java中如何跳出当前的多重嵌套循环">在Java中，如何跳出当前的多重嵌套循环？</h3><p data-anchor-id="dgqz">在最外层循环前加一个标记如A，然后用break A;可以跳出多重循环。（Java中支持带标签的break和continue语句，作用有点类似于C和C++中的goto语句，但是就像要避免使用goto一样，应该避免使用带标签的break和continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用，所以这种语法其实不知道更好）</p><div class="md-section-divider"></div><h3 data-anchor-id="fvjc" id="接口的意义">接口的意义</h3><p data-anchor-id="d7a0">接口的意义用三个词就可以概括:规范,扩展,回调.</p><div class="md-section-divider"></div><h4 data-anchor-id="mtmd" id="规范性">规范性</h4><p data-anchor-id="3u1y">所谓的规范性，当然规范java类的，为了避免类在设计上的不一致，很常见的，假如我们定义了一个类要实现【Comparator】接口，这个大家应该比较熟悉的吧，一个作用于比较的接口，实现这个接口，就必须去覆写它的compare(比较用来排序的两个参数)和equals(指示某个其他对象是否“等于”此 Comparator)方法,所以这样就形成了一种规范，要求以实现某个接口的时候，必须具备接口原来所具有的功能，这在大型开发中显的尤为重要</p><div class="md-section-divider"></div><h4 data-anchor-id="6cfp" id="易于拓展维护">易于拓展、维护</h4><p data-anchor-id="rw9h">比如你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类，可是在不久将来，你突然发现这个类满足不了你了，然后你又要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地方可能有引用他，这样修改起来很麻烦，如果你一开始定义一个接口，把绘制功能放在接口里，然后定义类时实现这个接口，然后你只要用这个接口去引用实现它的类就行了，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。</p><div class="md-section-divider"></div><h4 data-anchor-id="efqs" id="安全">安全</h4><p data-anchor-id="uis2">一个接口它只返回你想要的结果，而不提供程序实现的细节，对外皆是透明不可见，这样就比较的安全一些，严密些</p><div class="md-section-divider"></div><h3 data-anchor-id="3h9r" id="抽象类的意义">抽象类的意义</h3><p data-anchor-id="alcr">抽象类的意义可以用三句话来概括: <br>
1. 为其他子类提供一个公共的类型 <br>
2. 封装子类中重复定义的内容 <br>
3. 定义抽象方法,子类虽然有不同的实现,但是定义是一致的</p><div class="md-section-divider"></div><h3 data-anchor-id="698c" id="接口和抽象类的区别">接口和抽象类的区别</h3><table data-anchor-id="9e1u" class="table table-striped-white table-bordered">
<thead>
<tr>
 <th>比较</th>
 <th style="text-align:left;">抽象类</th>
 <th style="text-align:left;">接口</th>
</tr>
</thead>
<tbody><tr>
 <td>默认方法</td>
 <td style="text-align:left;">抽象类可以有默认的方法实现</td>
 <td style="text-align:left;">java 8之前,接口中不存在方法的实现.</td>
</tr>
<tr>
 <td>实现方式</td>
 <td style="text-align:left;">子类使用extends关键字来继承抽象类.如果子类不是抽象类,子类需要提供抽象类中所声明方法的实现.</td>
 <td style="text-align:left;">子类使用implements来实现接口,需要提供接口中所有声明的实现.</td>
</tr>
<tr>
 <td>构造器</td>
 <td style="text-align:left;">抽象类中可以有构造器, 接口中不能和正常类区别</td>
 <td style="text-align:left;">抽象类不能被实例化   接口则是完全不同的类型</td>
</tr>
<tr>
 <td>访问修饰符</td>
 <td style="text-align:left;">抽象方法可以有public,protected和default等修饰</td>
 <td style="text-align:left;">接口默认是public,不能使用其他修饰符</td>
</tr>
<tr>
 <td>多继承</td>
 <td style="text-align:left;">一个子类只能存在一个父类</td>
 <td style="text-align:left;">一个子类可以存在多个接口</td>
</tr>
<tr>
 <td>添加新方法</td>
 <td style="text-align:left;">想抽象类中添加新方法,可以提供默认的实现,因此可以不修改子类现有的代码</td>
 <td style="text-align:left;">如果往接口中添加新方法,则子类中需要实现该方法.</td>
</tr>
</tbody></table><div class="md-section-divider"></div><h3 data-anchor-id="yruo" id="静态嵌套类static-nested-class和内部类inner-class的不同">静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？</h3><p data-anchor-id="boy4">Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化</p><div class="md-section-divider"></div><h3 data-anchor-id="46su" id="父类的静态方法能否被子类重写">父类的静态方法能否被子类重写</h3><p data-anchor-id="8nc8">不能.重写只适用于实例方法,不能用于静态方法,而子类当中含有和父类相同签名的静态方法,我们一般称之为隐藏,调用的方法为定义的类所有的静态方法。</p><div class="md-section-divider"></div><h3 data-anchor-id="9m90" id="什么是不可变对象">什么是不可变对象</h3><p data-anchor-id="lcrc">不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。</p><div class="md-section-divider"></div><h3 data-anchor-id="jqut" id="静态变量和实例变量的区别">静态变量和实例变量的区别?</h3><p data-anchor-id="oxju">静态变量存储在方法区,属于类所有.</p><p data-anchor-id="uh6l">实例变量存储在堆当中,其引用存在当前线程栈.</p><div class="md-section-divider"></div><h3 data-anchor-id="t13m" id="能否创建一个包含可变对象的不可变对象">能否创建一个包含可变对象的不可变对象?</h3><p data-anchor-id="juz6">当然可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。</p><p data-anchor-id="ydjm">最常见的例子就是对象中包含一个日期对象的引用.</p><div class="md-section-divider"></div><h3 data-anchor-id="la9y" id="java-创建对象的几种方式">java 创建对象的几种方式</h3><ul data-anchor-id="b5iq">
<li>采用new</li>
<li>通过反射</li>
<li>采用clone</li>
<li>通过序列化机制</li>
</ul><p data-anchor-id="elj0">前2者都需要显式地调用构造方法. 造成耦合性最高的恰好是第一种,因此你发现无论什么框架,只要涉及到解耦必先减少new的使用.</p><div class="md-section-divider"></div><h3 data-anchor-id="59z9" id="switch中能否使用string做参数">switch中能否使用string做参数</h3><p data-anchor-id="99dk">在idk 1.7之前,switch只能支持byte,short,char,int或者其对应的封装类以及Enum类型。从idk 1.7之后switch开始支持String.</p><div class="md-section-divider"></div><h3 data-anchor-id="o99j" id="你对string对象的intern熟悉么">你对String对象的intern()熟悉么?</h3><p data-anchor-id="9vw1">intern()方法会首先从常量池中查找是否存在该常量值,如果常量池中不存在则现在常量池中创建,如果已经存在则直接返回.  <br>
比如  <br>
String s1=”aa”;  <br>
String s2=s1.intern();  <br>
System.out.print(s1==s2);//返回true</p><div class="md-section-divider"></div><h3 data-anchor-id="vy3u" id="object中有哪些公共方法">Object中有哪些公共方法?</h3><p data-anchor-id="yl2o">equals() <br>
clone() <br>
getClass() <br>
notify(),notifyAll(),wait() <br>
toString</p><div class="md-section-divider"></div><h3 data-anchor-id="kx1m" id="java当中的四种引用">java当中的四种引用</h3><p data-anchor-id="u5fm">强引用,软引用,弱引用,虚引用.不同的引用类型主要体现在GC上:</p><div class="md-section-divider"></div><h4 data-anchor-id="uh8o" id="强引用">强引用</h4><p data-anchor-id="ab0n">如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象</p><div class="md-section-divider"></div><h4 data-anchor-id="w5d3" id="软引用">软引用</h4><p data-anchor-id="e82p">在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。</p><div class="md-section-divider"></div><h4 data-anchor-id="4koz" id="弱引用">弱引用</h4><p data-anchor-id="hv3p">具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象</p><div class="md-section-divider"></div><h4 data-anchor-id="8f9o" id="虚引用">虚引用</h4><p data-anchor-id="cics">顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。</p><div class="md-section-divider"></div><h3 data-anchor-id="o2j1" id="为什么要有不同的引用类型">为什么要有不同的引用类型</h3><p data-anchor-id="ar0t">不像C语言,我们可以控制内存的申请和释放,在Java中有时候我们需要适当的控制对象被回收的时机,因此就诞生了不同的引用类型,可以说不同的引用类型实则是对GC回收时机不可控的妥协.</p><p data-anchor-id="27jt">有以下几个使用场景可以充分的说明:</p><p data-anchor-id="yl4a">利用软引用和弱引用解决OOM问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题.</p><p data-anchor-id="czmb">通过软引用实现Java对象的高速缓存:比如我们创建了一Person的类，如果每次需要查询一个人的信息,哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这将引起大量Person对象的消耗,并且由于这些对象的生命周期相对较短,会引起多次GC影响性能。此时,通过软引用和 HashMap 的结合可以构建高速缓存,提供性能.</p><div class="md-section-divider"></div><h3 data-anchor-id="ha9x" id="char-型变量中能不能存贮一个中文汉字为什么">char 型变量中能不能存贮一个中文汉字，为什么？</h3><p data-anchor-id="o8ez">char类型可以存储一个中文汉字，因为Java中使用的编码是Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个char类型占2个字节（16比特），所以放一个中文是没问题的。</p><div class="md-section-divider"></div><h3 data-anchor-id="imfc" id="java中和eqauls的区别equals和hashcode的区别">java中==和eqauls()的区别,equals()和hashcode的区别</h3><p data-anchor-id="o02k">==是运算符,用于比较两个变量是否相等,而equals是Object类的方法,用于比较两个对象是否相等.默认Object类的equals方法是比较两个对象的地址,此时和==的结果一样.</p><p data-anchor-id="edz2">换句话说:基本类型比较用==,比较的是他们的值.默认下,对象用==比较时,比较的是内存地址,如果需要比较对象内容,需要重写equal方法</p><div class="md-section-divider"></div><h3 data-anchor-id="mkjj" id="equals和hashcode的联系">equals()和hashcode()的联系</h3><p data-anchor-id="2q75">hashCode()是Object类的一个方法,返回一个哈希值.如果两个对象根据equal()方法比较相等,那么调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值. </p><p data-anchor-id="z2um">如果两个对象根据eqaul()方法比较不相等,那么产生的哈希值不一定相等(碰撞的情况下还是会相等的.)</p><div class="md-section-divider"></div><h3 data-anchor-id="70lz" id="ahashcode有什么用与aequalsb有什么关系">a.hashCode()有什么用?与a.equals(b)有什么关系</h3><p data-anchor-id="z9qx">hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。根据 Java 规范，使用 equal() 方法来判断两个相等的对象，必须具有相同的 hashcode。</p><p data-anchor-id="yjqi">将对象放入到集合中时,首先判断要放入对象的hashcode是否已经在集合中存在,不存在则直接放入集合.如果hashcode相等,然后通过equal()方法判断要放入对象与集合中的任意对象是否相等:如果equal()判断不相等,直接将该元素放入集合中,否则不放入.</p><div class="md-section-divider"></div><h3 data-anchor-id="y1ft" id="有没有可能两个不相等的对象有相同的hashcode">有没有可能两个不相等的对象有相同的hashcode</h3><p data-anchor-id="lpuh">有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会有冲突。如果两个对象相等，必须有相同的hashcode 值，反之不成立.</p><div class="md-section-divider"></div><h3 data-anchor-id="f3me" id="可以在hashcode中使用随机数字吗">可以在hashcode中使用随机数字吗?</h3><p data-anchor-id="unwf">不行，因为同一对象的 hashcode 值必须是相同的</p><div class="md-section-divider"></div><h3 data-anchor-id="phr2" id="ab与aequalsb有什么区别">a==b与a.equals(b)有什么区别</h3><p data-anchor-id="a4k6">如果a 和b 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。</p><p data-anchor-id="oyhw">例如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。</p><div class="md-section-divider"></div><h3 data-anchor-id="v3bj" id="30103返回值是什么">3*0.1==0.3返回值是什么</h3><p data-anchor-id="jroe">false，因为有些浮点数不能完全精确的表示出来。</p><div class="md-section-divider"></div><h3 data-anchor-id="cjj8" id="aab与ab有什么区别吗">a=a+b与a+=b有什么区别吗?</h3><p data-anchor-id="bntf">+=操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,而a=a+b则不会自动进行类型转换.如：  <br>
byte a = 127;  <br>
byte b = 127;  <br>
b = a + b; // error : cannot convert from int to byte  <br>
b += a; // ok  <br>
（译者注：这个地方应该表述的有误，其实无论 a+b 的值为多少，编译器都会报错，因为 a+b 操作会将 a、b 提升为 int 类型，所以将 int 类型赋值给 byte 就会编译出错）</p><div class="md-section-divider"></div><h3 data-anchor-id="k313" id="short-s11-s1-s1-1该段代码是否有错有的话怎么改">short s1=1; s1 = s1 + 1;该段代码是否有错,有的话怎么改？</h3><p data-anchor-id="kows">有错误,short类型在进行运算时会自动提升为int类型,也就是说s1+1的运算结果是int类型.</p><div class="md-section-divider"></div><h3 data-anchor-id="3egh" id="short-s11-s1-1-该段代码是否有错有的话怎么改">short s1=1; s1 += 1; 该段代码是否有错,有的话怎么改？</h3><p data-anchor-id="6wv1">+=操作符会自动对右边的表达式结果强转匹配左边的数据类型,所以没错.</p><div class="md-section-divider"></div><h3 data-anchor-id="v0er" id="和-的区别">&amp; 和 &amp;&amp;的区别</h3><p data-anchor-id="tg58">首先记住&amp;是位操作,而&amp;&amp;是逻辑运算符.另外需要记住逻辑运算符具有短路特性,而&amp;不具备短路特性.</p><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="8k81"><ol class="linenums"><li class="L0"><code class="language-java"><span class="kwd">public</span><span class="pln"> </span><span class="kwd">class</span><span class="pln"> </span><span class="typ">Test</span><span class="pun">{</span></code></li><li class="L1"><code class="language-java"><span class="pln">    </span><span class="kwd">static</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> name</span><span class="pun">;</span></code></li><li class="L2"><code class="language-java"></code></li><li class="L3"><code class="language-java"><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> main</span><span class="pun">(</span><span class="typ">String</span><span class="pun">[]</span><span class="pln"> args</span><span class="pun">){</span></code></li><li class="L4"><code class="language-java"><span class="pln">        </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">name</span><span class="pun">!=</span><span class="kwd">null</span><span class="pun">&amp;</span><span class="pln">userName</span><span class="pun">.</span><span class="pln">equals</span><span class="pun">(</span><span class="str">""</span><span class="pun">)){</span></code></li><li class="L5"><code class="language-java"><span class="pln">            </span><span class="typ">System</span><span class="pun">.</span><span class="pln">out</span><span class="pun">.</span><span class="pln">println</span><span class="pun">(</span><span class="str">"ok"</span><span class="pun">);</span></code></li><li class="L6"><code class="language-java"><span class="pln">        </span><span class="pun">}</span><span class="kwd">else</span><span class="pun">{</span></code></li><li class="L7"><code class="language-java"><span class="pln">            </span><span class="typ">System</span><span class="pun">.</span><span class="pln">out</span><span class="pun">.</span><span class="pln">println</span><span class="pun">(</span><span class="str">"erro"</span><span class="pun">);</span></code></li><li class="L8"><code class="language-java"><span class="pln">        </span><span class="pun">}</span></code></li><li class="L9"><code class="language-java"><span class="pln">    </span><span class="pun">}</span></code></li><li class="L0"><code class="language-java"><span class="pun">}</span></code></li></ol></pre><p data-anchor-id="r1n3">以上代码将会抛出空指针异常.</p><div class="md-section-divider"></div><h3 data-anchor-id="68fp" id="一个java文件内部可以有类非内部类">一个.java文件内部可以有类?(非内部类)</h3><p data-anchor-id="ig8b">只能有一个public公共类,但是可以有多个default修饰的类.</p><div class="md-section-divider"></div><h3 data-anchor-id="nru8" id="如何正确的退出多层嵌套循环">如何正确的退出多层嵌套循环.</h3><p data-anchor-id="j3z9">使用标号和break; <br>
通过在外层循环中添加标识符</p><div class="md-section-divider"></div><h3 data-anchor-id="nbfd" id="内部类的作用">内部类的作用</h3><p data-anchor-id="bpk4">内部类可以有多个实例,每个实例都有自己的状态信息,并且与其他外围对象的信息相互独立.在单个外围类当中,可以让多个内部类以不同的方式实现同一接口,或者继承同一个类.</p><p data-anchor-id="g83b">创建内部类对象的时刻不依赖于外部类对象的创建.内部类并没有令人疑惑的”is-a”关系,它就像是一个独立的实体.</p><p data-anchor-id="229z">内部类提供了更好的封装,除了该外围类,其他类都不能访问</p><div class="md-section-divider"></div><h3 data-anchor-id="blv5" id="finalfinalize和finally的不同之处">final,finalize和finally的不同之处</h3><div class="md-section-divider"></div><h4 data-anchor-id="ssow" id="final-是一个修饰符可以修饰变量方法和类如果-final-修饰变量意味着该变量的值在初始化后不能被改变">final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。</h4><div class="md-section-divider"></div><h4 data-anchor-id="ek23" id="finalize-方法是在对象被回收之前调用的方法给对象自己最后一个复活的机会但是什么时候调用-finalize-没有保证">finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。</h4><div class="md-section-divider"></div><h4 data-anchor-id="lkjk" id="finally-是一个关键字与-try-和-catch-一起用于异常的处理finally-块一定会被执行无论在-try-块中是否有发生异常">finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。</h4><div class="md-section-divider"></div><h3 data-anchor-id="y50d" id="finalize方法什么时候被调用析构函数finalization的目的是什么">finalize()方法什么时候被调用？析构函数(finalization)的目的是什么？</h3><p data-anchor-id="wuyv">垃圾回收器(garbage colector)决定回收某对象时，就会运行该对象的finalize()方法 但是在Java中很不幸，如果内存总是充足的，那么垃圾回收可能永远不会进行，也就是说filalize()可能永远不被执行，显然指望它做收尾工作是靠不住的。 那么finalize()究竟是做什么的呢？它最主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器，所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序（C或C++），finalize()的工作就是回收这部分的内存。</p><div class="md-section-divider"></div><h3 data-anchor-id="2e2c" id="clone是哪个类的方法">clone()是哪个类的方法?</h3><p data-anchor-id="delr">java.lang.Cloneable 是一个标示性接口，不包含任何方法，clone 方法在 object 类中定义。并且需要知道 clone() 方法是一个本地方法，这意味着它是由 c 或 c++ 或 其他本地语言实现的。</p><div class="md-section-divider"></div><h3 data-anchor-id="3s17" id="深拷贝和浅拷贝的区别是什么">深拷贝和浅拷贝的区别是什么?</h3><p data-anchor-id="txzd">浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。</p><p data-anchor-id="mct4">深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。</p><div class="md-section-divider"></div><h3 data-anchor-id="7rtu" id="static都有哪些用法">static都有哪些用法?</h3><p data-anchor-id="m5by">几乎所有的人都知道static关键字这两个基本的用法:静态变量和静态方法.也就是被static所修饰的变量/方法都属于类的静态资源,类实例所共享.</p><p data-anchor-id="64py">除了静态变量和静态方法之外,static也用于静态块,多用于初始化操作:</p><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="bmjm"><ol class="linenums"><li class="L0"><code class="language-java"><span class="kwd">public</span><span class="pln"> calss </span><span class="typ">PreCache</span><span class="pun">{</span></code></li><li class="L1"><code class="language-java"><span class="pln">    </span><span class="kwd">static</span><span class="pun">{</span></code></li><li class="L2"><code class="language-java"><span class="pln">        </span><span class="com">//执行相关操作</span></code></li><li class="L3"><code class="language-java"><span class="pln">    </span><span class="pun">}</span></code></li><li class="L4"><code class="language-java"><span class="pun">}</span></code></li></ol></pre><p data-anchor-id="vqkm">此外static也多用于修饰内部类,此时称之为静态内部类.</p><p data-anchor-id="bodj">最后一种用法就是静态导包,即import static.import static是在JDK 1.5之后引入的新特性,可以用来指定导入某个类中的静态资源,并且不需要使用类名.资源名,可以直接使用资源名,比如:</p><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="qmm4"><ol class="linenums"><li class="L0"><code class="language-java"><span class="kwd">import</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">lang</span><span class="pun">.</span><span class="typ">Math</span><span class="pun">.*;</span></code></li><li class="L1"><code class="language-java"></code></li><li class="L2"><code class="language-java"><span class="kwd">public</span><span class="pln"> </span><span class="kwd">class</span><span class="pln"> </span><span class="typ">Test</span><span class="pun">{</span></code></li><li class="L3"><code class="language-java"></code></li><li class="L4"><code class="language-java"><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> main</span><span class="pun">(</span><span class="typ">String</span><span class="pun">[]</span><span class="pln"> args</span><span class="pun">){</span></code></li><li class="L5"><code class="language-java"><span class="pln">        </span><span class="com">//System.out.println(Math.sin(20));传统做法</span></code></li><li class="L6"><code class="language-java"><span class="pln">        </span><span class="typ">System</span><span class="pun">.</span><span class="pln">out</span><span class="pun">.</span><span class="pln">println</span><span class="pun">(</span><span class="pln">sin</span><span class="pun">(</span><span class="lit">20</span><span class="pun">));</span></code></li><li class="L7"><code class="language-java"><span class="pln">    </span><span class="pun">}</span></code></li><li class="L8"><code class="language-java"><span class="pun">}</span></code></li></ol></pre><div class="md-section-divider"></div><h3 data-anchor-id="wg1q" id="final有哪些用法">final有哪些用法</h3><p data-anchor-id="ga1m">final也是很多面试喜欢问的地方,能回答下以下三点就不错了:  <br>
1. 被final修饰的类不可以被继承  <br>
2. 被final修饰的方法不可以被重写  <br>
3. 被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.  <br>
4. 被final修饰的方法,JVM会尝试将其内联,以提高运行效率  <br>
5. 被final修饰的常量,在编译阶段会存入常量池中.</p><div class="md-section-divider"></div><h3 data-anchor-id="r9xy" id="回答出编译器对final域要遵守的两个重排序规则更好">回答出编译器对final域要遵守的两个重排序规则更好:</h3><ol data-anchor-id="wb5a">
<li>在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序. </li>
<li>初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序.</li>
</ol><div class="md-section-divider"></div><h3 data-anchor-id="m57o" id="java中int-charlong各占多少字节">java中int char,long各占多少字节?</h3><table data-anchor-id="quo9" class="table table-striped-white table-bordered">
<thead>
<tr>
 <th>类型</th>
 <th>位数</th>
 <th>字节数</th>
</tr>
</thead>
<tbody><tr>
 <td>short</td>
 <td>2</td>
 <td>16</td>
</tr>
<tr>
 <td>int</td>
 <td>4</td>
 <td>32</td>
</tr>
<tr>
 <td>long</td>
 <td>8</td>
 <td>64</td>
</tr>
<tr>
 <td>float</td>
 <td>4</td>
 <td>32</td>
</tr>
<tr>
 <td>double</td>
 <td>8</td>
 <td>64</td>
</tr>
<tr>
 <td>char</td>
 <td>2</td>
 <td>16</td>
</tr>
</tbody></table><div class="md-section-divider"></div><h3 data-anchor-id="n20j" id="64位的jvm当中int的长度是多少">64位的JVM当中,int的长度是多少?</h3><p data-anchor-id="1fiy">Java 中，int 类型变量的长度是一个固定值，与平台无关，都是 32 位。</p><p data-anchor-id="5neg">意思就是说，在 32 位 和 64 位 的Java 虚拟机中，int 类型的长度是相同的。</p><div class="md-section-divider"></div><h3 data-anchor-id="2wfi" id="int和integer的区别">int和Integer的区别</h3><p data-anchor-id="l5m8">Integer是int的包装类型,在拆箱和装箱中,二者自动转换.int是基本类型，直接存数值，而integer是对象，用一个引用指向这个对象.</p><div class="md-section-divider"></div><h3 data-anchor-id="r3hh" id="int-和integer谁占用的内存更多">int 和Integer谁占用的内存更多?</h3><p data-anchor-id="sji1">Integer 对象会占用更多的内存。Integer是一个对象，需要存储对象的元数据。但是int是一个原始类型的数据，所以占用的空间更少。</p><div class="md-section-divider"></div><h3 data-anchor-id="1wks" id="stringstringbuffer和stringbuilder区别">String,StringBuffer和StringBuilder区别</h3><p data-anchor-id="s7mt">String是字符串常量,final修饰;StringBuffer字符串变量(线程安全);  <br>
StringBuilder 字符串变量(线程不安全).</p><div class="md-section-divider"></div><h4 data-anchor-id="xr3b" id="string和stringbuffer">String和StringBuffer</h4><p data-anchor-id="2wzk">String和StringBuffer主要区别是性能:String是不可变对象,每次对String类型进行操作都等同于产生了一个新的String对象,然后指向新的String对象.所以尽量不在对String进行大量的拼接操作,否则会产生很多临时对象,导致GC开始工作,影响系统性能.</p><p data-anchor-id="veh5">StringBuffer是对对象本身操作,而不是产生新的对象,因此在有大量拼接的情况下,我们建议使用StringBuffer.</p><p data-anchor-id="17c9">但是需要注意现在JVM会对String拼接做一定的优化:  <br>
String s=“This is only ”+”simple”+”test”会被虚拟机直接优化成String s=“This is only simple test”,此时就不存在拼接过程.</p><div class="md-section-divider"></div><h4 data-anchor-id="xzlz" id="stringbuffer和stringbuilder">StringBuffer和StringBuilder</h4><p data-anchor-id="tz3d">StringBuffer是线程安全的可变字符串,其内部实现是可变数组.StringBuilder是jdk 1.5新增的,其功能和StringBuffer类似,但是非线程安全.因此,在没有多线程问题的前提下,使用StringBuilder会取得更好的性能.</p><div class="md-section-divider"></div><h3 data-anchor-id="1oc4" id="什么是编译器常量使用它有什么风险">什么是编译器常量?使用它有什么风险?</h3><p data-anchor-id="h17l">公共静态不可变（public static final）变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，因为编译器知道这些变量的值，并且知道这些变量在运行时不能改变。这种方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量，但是这个值后面被其他人改变了，但是你的客户端仍然在使用老的值，甚至你已经部署了一个新的jar。为了避免这种情况，当你在更新依赖 JAR 文件时，确保重新编译你的程序。</p><div class="md-section-divider"></div><h3 data-anchor-id="bz5x" id="java当中使用什么类型表示价格比较好">java当中使用什么类型表示价格比较好?</h3><p data-anchor-id="ant5">如果不是特别关心内存和性能的话，使用BigDecimal，否则使用预定义精度的 double 类型。</p><div class="md-section-divider"></div><h3 data-anchor-id="l0fp" id="如何将byte转为string">如何将byte转为String</h3><p data-anchor-id="s6pm">可以使用 String 接收 byte[] 参数的构造器来进行转换，需要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码相同，也可能不同。</p><div class="md-section-divider"></div><h3 data-anchor-id="01tc" id="可以将int强转为byte类型么会产生什么问题">可以将int强转为byte类型么?会产生什么问题?</h3><p data-anchor-id="5f1b">我们可以做强制转换，但是Java中int是32位的而byte是8 位的，所以,如果强制转化int类型的高24位将会被丢弃，byte 类型的范围是从-128到128</p><p data-anchor-id="olwz">Java 中会存在内存泄漏吗，请简单描述。  <br>
答：理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄露的发生。例如hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露。下面例子中的代码也会导致内存泄露。</p><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="ui03"><ol class="linenums"><li class="L0"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">util</span><span class="pun">.</span><span class="typ">Arrays</span><span class="pun">;</span></code></li><li class="L1"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">util</span><span class="pun">.</span><span class="typ">EmptyStackException</span><span class="pun">;</span></code></li><li class="L2"><code></code></li><li class="L3"><code><span class="kwd">public</span><span class="pln"> </span><span class="kwd">class</span><span class="pln"> </span><span class="typ">MyStack</span><span class="pun">&lt;</span><span class="pln">T</span><span class="pun">&gt;</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L4"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> T</span><span class="pun">[]</span><span class="pln"> elements</span><span class="pun">;</span></code></li><li class="L5"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> size </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></code></li><li class="L6"><code></code></li><li class="L7"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="kwd">final</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> INIT_CAPACITY </span><span class="pun">=</span><span class="pln"> </span><span class="lit">16</span><span class="pun">;</span></code></li><li class="L8"><code></code></li><li class="L9"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">MyStack</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L0"><code><span class="pln">        elements </span><span class="pun">=</span><span class="pln"> </span><span class="pun">(</span><span class="pln">T</span><span class="pun">[])</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Object</span><span class="pun">[</span><span class="pln">INIT_CAPACITY</span><span class="pun">];</span></code></li><li class="L1"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L2"><code></code></li><li class="L3"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> push</span><span class="pun">(</span><span class="pln">T elem</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L4"><code><span class="pln">        ensureCapacity</span><span class="pun">();</span></code></li><li class="L5"><code><span class="pln">        elements</span><span class="pun">[</span><span class="pln">size</span><span class="pun">++]</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> elem</span><span class="pun">;</span></code></li><li class="L6"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L7"><code></code></li><li class="L8"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> T pop</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L9"><code><span class="pln">        </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">size </span><span class="pun">==</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span></code></li><li class="L0"><code><span class="pln">            </span><span class="kwd">throw</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">EmptyStackException</span><span class="pun">();</span></code></li><li class="L1"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> elements</span><span class="pun">[--</span><span class="pln">size</span><span class="pun">];</span></code></li><li class="L2"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L3"><code></code></li><li class="L4"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> ensureCapacity</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L5"><code><span class="pln">        </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">elements</span><span class="pun">.</span><span class="pln">length </span><span class="pun">==</span><span class="pln"> size</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L6"><code><span class="pln">            elements </span><span class="pun">=</span><span class="pln"> </span><span class="typ">Arrays</span><span class="pun">.</span><span class="pln">copyOf</span><span class="pun">(</span><span class="pln">elements</span><span class="pun">,</span><span class="pln"> </span><span class="lit">2</span><span class="pln"> </span><span class="pun">*</span><span class="pln"> size </span><span class="pun">+</span><span class="pln"> </span><span class="lit">1</span><span class="pun">);</span></code></li><li class="L7"><code><span class="pln">        </span><span class="pun">}</span></code></li><li class="L8"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L9"><code><span class="pun">}</span></code></li></ol></pre><p data-anchor-id="9yjt">上面的代码实现了一个栈（先进后出（FILO））结构，乍看之下似乎没有什么明显的问题，它甚至可以通过你编写的各种单元测试。然而其中的pop方法却存在内存泄露的问题，当我们用pop方法弹出栈中的对象时，该对象不会被当作垃圾回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过期引用（obsolete reference）。在支持垃圾回收的语言中，内存泄露是很隐蔽的，这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了，那么垃圾回收器不会处理这个对象，也不会处理该对象引用的其他对象，即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，从而对性能造成重大影响，极端情况下会引发Disk Paging（物理内存与硬盘的虚拟内存交换数据），甚至造成OutOfMemoryError。</p><div class="md-section-divider"></div><h3 data-anchor-id="c626" id="如何实现对象克隆">如何实现对象克隆？</h3><p data-anchor-id="cxxe">答：有两种方式：  <br>
  1). 实现Cloneable接口并重写Object类中的clone()方法；  <br>
  2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。</p><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="e2bi"><ol class="linenums"><li class="L0"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">io</span><span class="pun">.</span><span class="typ">ByteArrayInputStream</span><span class="pun">;</span></code></li><li class="L1"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">io</span><span class="pun">.</span><span class="typ">ByteArrayOutputStream</span><span class="pun">;</span></code></li><li class="L2"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">io</span><span class="pun">.</span><span class="typ">ObjectInputStream</span><span class="pun">;</span></code></li><li class="L3"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">io</span><span class="pun">.</span><span class="typ">ObjectOutputStream</span><span class="pun">;</span></code></li><li class="L4"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">io</span><span class="pun">.</span><span class="typ">Serializable</span><span class="pun">;</span></code></li><li class="L5"><code></code></li><li class="L6"><code><span class="kwd">public</span><span class="pln"> </span><span class="kwd">class</span><span class="pln"> </span><span class="typ">MyUtil</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L7"><code></code></li><li class="L8"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="typ">MyUtil</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L9"><code><span class="pln">        </span><span class="kwd">throw</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">AssertionError</span><span class="pun">();</span></code></li><li class="L0"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L1"><code></code></li><li class="L2"><code><span class="pln">    </span><span class="lit">@SuppressWarnings</span><span class="pun">(</span><span class="str">"unchecked"</span><span class="pun">)</span></code></li><li class="L3"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="pun">&lt;</span><span class="pln">T </span><span class="kwd">extends</span><span class="pln"> </span><span class="typ">Serializable</span><span class="pun">&gt;</span><span class="pln"> T clone</span><span class="pun">(</span><span class="pln">T obj</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">throws</span><span class="pln"> </span><span class="typ">Exception</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L4"><code><span class="pln">        </span><span class="typ">ByteArrayOutputStream</span><span class="pln"> bout </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">ByteArrayOutputStream</span><span class="pun">();</span></code></li><li class="L5"><code><span class="pln">        </span><span class="typ">ObjectOutputStream</span><span class="pln"> oos </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">ObjectOutputStream</span><span class="pun">(</span><span class="pln">bout</span><span class="pun">);</span></code></li><li class="L6"><code><span class="pln">        oos</span><span class="pun">.</span><span class="pln">writeObject</span><span class="pun">(</span><span class="pln">obj</span><span class="pun">);</span></code></li><li class="L7"><code></code></li><li class="L8"><code><span class="pln">        </span><span class="typ">ByteArrayInputStream</span><span class="pln"> bin </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">ByteArrayInputStream</span><span class="pun">(</span><span class="pln">bout</span><span class="pun">.</span><span class="pln">toByteArray</span><span class="pun">());</span></code></li><li class="L9"><code><span class="pln">        </span><span class="typ">ObjectInputStream</span><span class="pln"> ois </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">ObjectInputStream</span><span class="pun">(</span><span class="pln">bin</span><span class="pun">);</span></code></li><li class="L0"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> </span><span class="pun">(</span><span class="pln">T</span><span class="pun">)</span><span class="pln"> ois</span><span class="pun">.</span><span class="pln">readObject</span><span class="pun">();</span></code></li><li class="L1"><code></code></li><li class="L2"><code><span class="pln">        </span><span class="com">// 说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义</span></code></li><li class="L3"><code><span class="pln">        </span><span class="com">// 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放</span></code></li><li class="L4"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L5"><code><span class="pun">}</span></code></li></ol></pre><p data-anchor-id="kmek">下面是测试代码：</p><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="bcjr"><ol class="linenums"><li class="L0"><code><span class="kwd">import</span><span class="pln"> java</span><span class="pun">.</span><span class="pln">io</span><span class="pun">.</span><span class="typ">Serializable</span><span class="pun">;</span></code></li><li class="L1"><code></code></li><li class="L2"><code><span class="com">/**</span></code></li><li class="L3"><code><span class="com"> * 人类</span></code></li><li class="L4"><code><span class="com"> * @author 骆昊</span></code></li><li class="L5"><code><span class="com"> *</span></code></li><li class="L6"><code><span class="com"> */</span></code></li><li class="L7"><code><span class="kwd">class</span><span class="pln"> </span><span class="typ">Person</span><span class="pln"> </span><span class="kwd">implements</span><span class="pln"> </span><span class="typ">Serializable</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L8"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="kwd">final</span><span class="pln"> </span><span class="kwd">long</span><span class="pln"> serialVersionUID </span><span class="pun">=</span><span class="pln"> </span><span class="pun">-</span><span class="lit">9102017020286042305L</span><span class="pun">;</span></code></li><li class="L9"><code></code></li><li class="L0"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> name</span><span class="pun">;</span><span class="pln">    </span><span class="com">// 姓名</span></code></li><li class="L1"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> age</span><span class="pun">;</span><span class="pln">        </span><span class="com">// 年龄</span></code></li><li class="L2"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="typ">Car</span><span class="pln"> car</span><span class="pun">;</span><span class="pln">        </span><span class="com">// 座驾</span></code></li><li class="L3"><code></code></li><li class="L4"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">Person</span><span class="pun">(</span><span class="typ">String</span><span class="pln"> name</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> age</span><span class="pun">,</span><span class="pln"> </span><span class="typ">Car</span><span class="pln"> car</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L5"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">name </span><span class="pun">=</span><span class="pln"> name</span><span class="pun">;</span></code></li><li class="L6"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">age </span><span class="pun">=</span><span class="pln"> age</span><span class="pun">;</span></code></li><li class="L7"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">car </span><span class="pun">=</span><span class="pln"> car</span><span class="pun">;</span></code></li><li class="L8"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L9"><code></code></li><li class="L0"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> getName</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L1"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> name</span><span class="pun">;</span></code></li><li class="L2"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L3"><code></code></li><li class="L4"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> setName</span><span class="pun">(</span><span class="typ">String</span><span class="pln"> name</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L5"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">name </span><span class="pun">=</span><span class="pln"> name</span><span class="pun">;</span></code></li><li class="L6"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L7"><code></code></li><li class="L8"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> getAge</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L9"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> age</span><span class="pun">;</span></code></li><li class="L0"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L1"><code></code></li><li class="L2"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> setAge</span><span class="pun">(</span><span class="kwd">int</span><span class="pln"> age</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L3"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">age </span><span class="pun">=</span><span class="pln"> age</span><span class="pun">;</span></code></li><li class="L4"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L5"><code></code></li><li class="L6"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">Car</span><span class="pln"> getCar</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L7"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> car</span><span class="pun">;</span></code></li><li class="L8"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L9"><code></code></li><li class="L0"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> setCar</span><span class="pun">(</span><span class="typ">Car</span><span class="pln"> car</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L1"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">car </span><span class="pun">=</span><span class="pln"> car</span><span class="pun">;</span></code></li><li class="L2"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L3"><code></code></li><li class="L4"><code><span class="pln">    </span><span class="lit">@Override</span></code></li><li class="L5"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> toString</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L6"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> </span><span class="str">"Person [name="</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> name </span><span class="pun">+</span><span class="pln"> </span><span class="str">", age="</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> age </span><span class="pun">+</span><span class="pln"> </span><span class="str">", car="</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> car </span><span class="pun">+</span><span class="pln"> </span><span class="str">"]"</span><span class="pun">;</span></code></li><li class="L7"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L8"><code></code></li><li class="L9"><code><span class="pun">}</span></code></li></ol></pre><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="0apb"><ol class="linenums"><li class="L0"><code><span class="com">/**</span></code></li><li class="L1"><code><span class="com"> * 小汽车类</span></code></li><li class="L2"><code><span class="com"> * @author 骆昊</span></code></li><li class="L3"><code><span class="com"> *</span></code></li><li class="L4"><code><span class="com"> */</span></code></li><li class="L5"><code><span class="kwd">class</span><span class="pln"> </span><span class="typ">Car</span><span class="pln"> </span><span class="kwd">implements</span><span class="pln"> </span><span class="typ">Serializable</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L6"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="kwd">final</span><span class="pln"> </span><span class="kwd">long</span><span class="pln"> serialVersionUID </span><span class="pun">=</span><span class="pln"> </span><span class="pun">-</span><span class="lit">5713945027627603702L</span><span class="pun">;</span></code></li><li class="L7"><code></code></li><li class="L8"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> brand</span><span class="pun">;</span><span class="pln">       </span><span class="com">// 品牌</span></code></li><li class="L9"><code><span class="pln">    </span><span class="kwd">private</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> maxSpeed</span><span class="pun">;</span><span class="pln">       </span><span class="com">// 最高时速</span></code></li><li class="L0"><code></code></li><li class="L1"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">Car</span><span class="pun">(</span><span class="typ">String</span><span class="pln"> brand</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> maxSpeed</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L2"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">brand </span><span class="pun">=</span><span class="pln"> brand</span><span class="pun">;</span></code></li><li class="L3"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">maxSpeed </span><span class="pun">=</span><span class="pln"> maxSpeed</span><span class="pun">;</span></code></li><li class="L4"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L5"><code></code></li><li class="L6"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> getBrand</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L7"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> brand</span><span class="pun">;</span></code></li><li class="L8"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L9"><code></code></li><li class="L0"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> setBrand</span><span class="pun">(</span><span class="typ">String</span><span class="pln"> brand</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L1"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">brand </span><span class="pun">=</span><span class="pln"> brand</span><span class="pun">;</span></code></li><li class="L2"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L3"><code></code></li><li class="L4"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">int</span><span class="pln"> getMaxSpeed</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L5"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> maxSpeed</span><span class="pun">;</span></code></li><li class="L6"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L7"><code></code></li><li class="L8"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> setMaxSpeed</span><span class="pun">(</span><span class="kwd">int</span><span class="pln"> maxSpeed</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L9"><code><span class="pln">        </span><span class="kwd">this</span><span class="pun">.</span><span class="pln">maxSpeed </span><span class="pun">=</span><span class="pln"> maxSpeed</span><span class="pun">;</span></code></li><li class="L0"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L1"><code></code></li><li class="L2"><code><span class="pln">    </span><span class="lit">@Override</span></code></li><li class="L3"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="typ">String</span><span class="pln"> toString</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L4"><code><span class="pln">        </span><span class="kwd">return</span><span class="pln"> </span><span class="str">"Car [brand="</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> brand </span><span class="pun">+</span><span class="pln"> </span><span class="str">", maxSpeed="</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> maxSpeed </span><span class="pun">+</span><span class="pln"> </span><span class="str">"]"</span><span class="pun">;</span></code></li><li class="L5"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L6"><code></code></li><li class="L7"><code><span class="pun">}</span></code></li></ol></pre><div class="md-section-divider"></div><pre class="prettyprint linenums prettyprinted" data-anchor-id="0lph"><ol class="linenums"><li class="L0"><code><span class="kwd">class</span><span class="pln"> </span><span class="typ">CloneTest</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L1"><code></code></li><li class="L2"><code><span class="pln">    </span><span class="kwd">public</span><span class="pln"> </span><span class="kwd">static</span><span class="pln"> </span><span class="kwd">void</span><span class="pln"> main</span><span class="pun">(</span><span class="typ">String</span><span class="pun">[]</span><span class="pln"> args</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L3"><code><span class="pln">        </span><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L4"><code><span class="pln">            </span><span class="typ">Person</span><span class="pln"> p1 </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Person</span><span class="pun">(</span><span class="str">"Hao LUO"</span><span class="pun">,</span><span class="pln"> </span><span class="lit">33</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Car</span><span class="pun">(</span><span class="str">"Benz"</span><span class="pun">,</span><span class="pln"> </span><span class="lit">300</span><span class="pun">));</span></code></li><li class="L5"><code><span class="pln">            </span><span class="typ">Person</span><span class="pln"> p2 </span><span class="pun">=</span><span class="pln"> </span><span class="typ">MyUtil</span><span class="pun">.</span><span class="pln">clone</span><span class="pun">(</span><span class="pln">p1</span><span class="pun">);</span><span class="pln">   </span><span class="com">// 深度克隆</span></code></li><li class="L6"><code><span class="pln">            p2</span><span class="pun">.</span><span class="pln">getCar</span><span class="pun">().</span><span class="pln">setBrand</span><span class="pun">(</span><span class="str">"BYD"</span><span class="pun">);</span></code></li><li class="L7"><code><span class="pln">            </span><span class="com">// 修改克隆的Person对象p2关联的汽车对象的品牌属性</span></code></li><li class="L8"><code><span class="pln">            </span><span class="com">// 原来的Person对象p1关联的汽车不会受到任何影响</span></code></li><li class="L9"><code><span class="pln">            </span><span class="com">// 因为在克隆Person对象时其关联的汽车对象也被克隆了</span></code></li><li class="L0"><code><span class="pln">            </span><span class="typ">System</span><span class="pun">.</span><span class="kwd">out</span><span class="pun">.</span><span class="pln">println</span><span class="pun">(</span><span class="pln">p1</span><span class="pun">);</span></code></li><li class="L1"><code><span class="pln">        </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="typ">Exception</span><span class="pln"> e</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></code></li><li class="L2"><code><span class="pln">            e</span><span class="pun">.</span><span class="pln">printStackTrace</span><span class="pun">();</span></code></li><li class="L3"><code><span class="pln">        </span><span class="pun">}</span></code></li><li class="L4"><code><span class="pln">    </span><span class="pun">}</span></code></li><li class="L5"><code><span class="pun">}</span></code></li></ol></pre><p data-anchor-id="v5xy">注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。</p><div class="md-section-divider"></div><h3 data-anchor-id="2xn4" id="简述一下面向对象的六原则一法则">简述一下面向对象的"六原则一法则"。</h3><p data-anchor-id="eyue">答：  <br>
- 单一职责原则：一个类只做它该做的事情。（单一职责原则想表达的就是"高内聚"，写代码最终极的原则只有六个字"高内聚、低耦合"，就如同葵花宝典或辟邪剑谱的中心思想就八个字"欲练此功必先自宫"，所谓的高内聚就是一个代码模块只完成一项功能，在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。我们都知道一句话叫"因为专注，所以专业"，一个对象如果承担太多的职责，那么注定它什么都做不好。这个世界上任何好的东西都有两个特征，一个是功能单一，好的相机绝对不是电视购物里面卖的那种一个机器有一百多种功能的，它基本上只能照相；另一个是模块化，好的自行车是组装车，从减震叉、刹车到变速器，所有的部件都是可以拆卸和重新组装的，好的乒乓球拍也不是成品拍，一定是底板和胶皮可以拆分和自行组装的，一个好的软件系统，它里面的每个功能模块也应该是可以轻易的拿到其他系统中使用的，这样才能实现软件复用的目标。）  <br>
- 开闭原则：软件实体应当对扩展开放，对修改关闭。（在理想的状态下，当我们需要为一个软件系统增加新功能时，只需要从原来的系统派生出一些新类就可以，不需要修改原来的任何一行代码。要做到开闭有两个要点：①抽象是关键，一个系统中如果没有抽象类或接口系统就没有扩展点；②封装可变性，将系统中的各种可变因素封装到一个继承结构中，如果多个可变因素混杂在一起，系统将变得复杂而换乱，如果不清楚如何封装可变性，可以参考《设计模式精解》一书中对桥梁模式的讲解的章节。）  <br>
- 依赖倒转原则：面向接口编程。（该原则说得直白和具体一些就是声明方法的参数类型、方法的返回类型、变量的引用类型时，尽可能使用抽象类型而不用具体类型，因为抽象类型可以被它的任何一个子类型所替代，请参考下面的里氏替换原则。）  <br>
里氏替换原则：任何时候都可以用子类型替换掉父类型。（关于里氏替换原则的描述，Barbara Liskov女士的描述比这个要复杂得多，但简单的说就是能用父类型的地方就一定能使用子类型。里氏替换原则可以检查继承关系是否合理，如果一个继承关系违背了里氏替换原则，那么这个继承关系一定是错误的，需要对代码进行重构。例如让猫继承狗，或者狗继承猫，又或者让正方形继承长方形都是错误的继承关系，因为你很容易找到违反里氏替换原则的场景。需要注意的是：子类一定是增加父类的能力而不是减少父类的能力，因为子类比父类的能力更多，把能力多的对象当成能力少的对象来用当然没有任何问题。）  <br>
- 接口隔离原则：接口要小而专，绝不能大而全。（臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。例如，琴棋书画就应该分别设计为四个接口，而不应设计成一个接口中的四个方法，因为如果设计成一个接口中的四个方法，那么这个接口很难用，毕竟琴棋书画四样都精通的人还是少数，而如果设计成四个接口，会几项就实现几个接口，这样的话每个接口被复用的可能性是很高的。Java中的接口代表能力、代表约定、代表角色，能否正确的使用接口一定是编程水平高低的重要标识。）  <br>
- 合成聚合复用原则：优先使用聚合或合成关系复用代码。（通过继承来复用代码是面向对象程序设计中被滥用得最多的东西，因为所有的教科书都无一例外的对继承进行了鼓吹从而误导了初学者，类与类之间简单的说有三种关系，Is-A关系、Has-A关系、Use-A关系，分别代表继承、关联和依赖。其中，关联关系根据其关联的强度又可以进一步划分为关联、聚合和合成，但说白了都是Has-A关系，合成聚合复用原则想表达的是优先考虑Has-A关系而不是Is-A关系复用代码，原因嘛可以自己从百度上找到一万个理由，需要说明的是，即使在Java的API中也有不少滥用继承的例子，例如Properties类继承了Hashtable类，Stack类继承了Vector类，这些继承明显就是错误的，更好的做法是在Properties类中放置一个Hashtable类型的成员并且将其键和值都设置为字符串来存储数据，而Stack类的设计也应该是在Stack类中放一个Vector对象来存储数据。记住：任何时候都不要继承工具类，工具是可以拥有并可以使用的，而不是拿来继承的。）  <br>
- 迪米特法则：迪米特法则又叫最少知识原则，一个对象应当对其他对象有尽可能少的了解。（迪米特法则简单的说就是如何做到"低耦合"，门面模式和调停者模式就是对迪米特法则的践行。对于门面模式可以举一个简单的例子，你去一家公司洽谈业务，你不需要了解这个公司内部是如何运作的，你甚至可以对这个公司一无所知，去的时候只需要找到公司入口处的前台美女，告诉她们你要做什么，她们会找到合适的人跟你接洽，前台的美女就是公司这个系统的门面。再复杂的系统都可以为用户提供一个简单的门面，Java Web开发中作为前端控制器的Servlet或Filter不就是一个门面吗，浏览器对服务器的运作方式一无所知，但是通过前端控制器就能够根据你的请求得到相应的服务。调停者模式也可以举一个简单的例子来说明，例如一台计算机，CPU、内存、硬盘、显卡、声卡各种设备需要相互配合才能很好的工作，但是如果这些东西都直接连接到一起，计算机的布线将异常复杂，在这种情况下，主板作为一个调停者的身份出现，它将各个设备连接在一起而不需要每个设备之间直接交换数据，这样就减小了系统的耦合度和复杂度，如下图所示。迪米特法则用通俗的话来将就是不要和陌生人打交道，如果真的需要，找一个自己的朋友，让他替你和陌生人打交道。） <br>
<img src="http://static.zybuluo.com/homiss/n9kf72vv1laidv2s90aogr3f/image_1bmf4eabl1hlogd1tto8jn17a89.png" alt="image_1bmf4eabl1hlogd1tto8jn17a89.png-25.4kB" title=""></p><p data-anchor-id="7oks"><img src="http://static.zybuluo.com/homiss/jyay4t960drjkn8m80ayfhy5/image_1bmf4eu1u1ia03nu7421jvsjgvm.png" alt="image_1bmf4eu1u1ia03nu7421jvsjgvm.png-19kB" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="ydq7" id="什么是rmi">什么是RMI？</h3><p data-anchor-id="j8d3">Java远程方法调用(Java RMI)是Java API对远程过程调用(RPC)提供的面向对象的等价形式，支持直接传输序列化的Java对象和分布式垃圾回收。远程方法调用可以看做是激活远程正在运行的对象上的方法的步骤。RMI对调用者是位置透明的，因为调用者感觉方法是执行在本地运行的对象上的。看下RMI的一些注意事项。</p><div class="md-section-divider"></div><h3 data-anchor-id="2spq" id="rmi体系结构的基本原则是什么">RMI体系结构的基本原则是什么？</h3><p data-anchor-id="0xhs">RMI体系结构是基于一个非常重要的行为定义和行为实现相分离的原则。RMI允许定义行为的代码和实现行为的代码相分离，并且运行在不同的JVM上。</p><div class="md-section-divider"></div><h3 data-anchor-id="s2oo" id="rmi体系结构分哪几层">RMI体系结构分哪几层？</h3><p data-anchor-id="79c2">RMI体系结构分以下几层： <br>
存根和骨架层(Stub and Skeleton layer)：这一层对程序员是透明的，它主要负责拦截客户端发出的方法调用请求，然后把请求重定向给远程的RMI服务。 <br>
远程引用层(Remote Reference Layer)：RMI体系结构的第二层用来解析客户端对服务端远程对象的引用。这一层解析并管理客户端对服务端远程对象的引用。连接是点到点的。 <br>
传输层(Transport layer)：这一层负责连接参与服务的两个JVM。这一层是建立在网络上机器间的TCP/IP连接之上的。它提供了基本的连接服务，还有一些防火墙穿透策略。</p><div class="md-section-divider"></div><h3 data-anchor-id="goy9" id="rmi中的远程接口remote-interface扮演了什么样的角色">RMI中的远程接口(Remote Interface)扮演了什么样的角色？</h3><p data-anchor-id="fja9">远程接口用来标识哪些方法是可以被非本地虚拟机调用的接口。远程对象必须要直接或者是间接实现远程接口。实现了远程接口的类应该声明被实现的远程接口，给每一个远程对象定义构造函数，给所有远程接口的方法提供实现。</p><div class="md-section-divider"></div><h3 data-anchor-id="3r8p" id="javarminaming类扮演了什么样的角色">java.rmi.Naming类扮演了什么样的角色？</h3><p data-anchor-id="we1q">java.rmi.Naming类用来存储和获取在远程对象注册表里面的远程对象的引用。Naming类的每一个方法接收一个URL格式的String对象作为它的参数。</p><div class="md-section-divider"></div><h3 data-anchor-id="4dgf" id="rmi的绑定binding是什么意思">RMI的绑定(Binding)是什么意思？</h3><p data-anchor-id="1n9d">绑定是为了查询找远程对象而给远程对象关联或者是注册以后会用到的名称的过程。远程对象可以使用Naming类的bind()或者rebind()方法跟名称相关联。</p><div class="md-section-divider"></div><h3 data-anchor-id="uucu" id="naming类的bind和rebind方法有什么区别">Naming类的bind()和rebind()方法有什么区别？</h3><p data-anchor-id="jjae">bind()方法负责把指定名称绑定给远程对象，rebind()方法负责把指定名称重新绑定到一个新的远程对象。如果那个名称已经绑定过了，先前的绑定会被替换掉。</p><div class="md-section-divider"></div><h3 data-anchor-id="2jpf" id="让rmi程序能正确运行有哪些步骤">让RMI程序能正确运行有哪些步骤？</h3><p data-anchor-id="ulrl">为了让RMI程序能正确运行必须要包含以下几个步骤： <br>
编译所有的源文件。 <br>
使用rmic生成stub。 <br>
启动rmiregistry。 <br>
启动RMI服务器。 <br>
运行客户端程序。</p><div class="md-section-divider"></div><h3 data-anchor-id="4px4" id="rmi的stub扮演了什么样的角色">RMI的stub扮演了什么样的角色？</h3><p data-anchor-id="7dlt">远程对象的stub扮演了远程对象的代表或者代理的角色。调用者在本地stub上调用方法，它负责在远程对象上执行方法。当stub的方法被调用的时候，会经历以下几个步骤： <br>
初始化到包含了远程对象的JVM的连接。 <br>
序列化参数到远程的JVM。 <br>
等待方法调用和执行的结果。 <br>
反序列化返回的值或者是方法没有执行成功情况下的异常。 <br>
把值返回给调用者。</p><div class="md-section-divider"></div><h3 data-anchor-id="3vi0" id="什么是分布式垃圾回收dgc它是如何工作的">什么是分布式垃圾回收(DGC)？它是如何工作的？</h3><p data-anchor-id="aetx">DGC叫做分布式垃圾回收。RMI使用DGC来做自动垃圾回收。因为RMI包含了跨虚拟机的远程对象的引用，垃圾回收是很困难的。DGC使用引用计数算法来给远程对象提供自动内存管理。</p><div class="md-section-divider"></div><h3 data-anchor-id="n5wy" id="rmi中使用rmi安全管理器rmisecuritymanager的目的是什么">RMI中使用RMI安全管理器(RMISecurityManager)的目的是什么？</h3><p data-anchor-id="9p3l">RMISecurityManager使用下载好的代码提供可被RMI应用程序使用的安全管理器。如果没有设置安全管理器，RMI的类加载器就不会从远程下载任何的类。</p><div class="md-section-divider"></div><h3 data-anchor-id="s80n" id="解释下marshalling和demarshalling">解释下Marshalling和demarshalling。</h3><p data-anchor-id="t3q2">当应用程序希望把内存对象跨网络传递到另一台主机或者是持久化到存储的时候，就必须要把对象在内存里面的表示转化成合适的格式。这个过程就叫做Marshalling，反之就是demarshalling。</p><div class="md-section-divider"></div><h3 data-anchor-id="cg4c" id="解释下serialization和deserialization">解释下Serialization和Deserialization。</h3><p data-anchor-id="ilcw">Java提供了一种叫做对象序列化的机制，他把对象表示成一连串的字节，里面包含了对象的数据，对象的类型信息，对象内部的数据的类型信息等等。因此，序列化可以看成是为了把对象存储在磁盘上或者是从磁盘上读出来并重建对象而把对象扁平化的一种方式。反序列化是把对象从扁平状态转化成活动对象的相反的步骤。</p><div class="md-section-divider"></div><h3 data-anchor-id="b0j9" id="解释下servlet的生命周期">解释下Servlet的生命周期。</h3><p data-anchor-id="xyoq">对每一个客户端的请求，Servlet引擎载入Servlet，调用它的init()方法，完成Servlet的初始化。然后，Servlet对象通过为每一个请求单独调用service()方法来处理所有随后来自客户端的请求，最后，调用Servlet(译者注：这里应该是Servlet而不是server)的destroy()方法把Servlet删除掉。</p><div class="md-section-divider"></div><h3 data-anchor-id="r19u" id="什么是servlet链servlet-chaining">什么是Servlet链(Servlet Chaining)？</h3><p data-anchor-id="g9ue">Servlet链是把一个Servlet的输出发送给另一个Servlet的方法。第二个Servlet的输出可以发送给第三个Servlet，依次类推。链条上最后一个Servlet负责把响应发送给客户端。</p><div class="md-section-divider"></div><h3 data-anchor-id="zry6" id="如何知道是哪一个客户端的机器正在请求你的servlet">如何知道是哪一个客户端的机器正在请求你的Servlet？</h3><p data-anchor-id="nacc">ServletRequest类可以找出客户端机器的IP地址或者是主机名。getRemoteAddr()方法获取客户端主机的IP地址，getRemoteHost()可以获取主机名。看下这里的例子。</p><div class="md-section-divider"></div><h3 data-anchor-id="k5hc" id="http响应的结构是怎么样的">HTTP响应的结构是怎么样的？</h3><p data-anchor-id="6ylb">HTTP响应由三个部分组成： <br>
状态码(Status Code)：描述了响应的状态。可以用来检查是否成功的完成了请求。请求失败的情况下，状态码可用来找出失败的原因。如果Servlet没有返回状态码，默认会返回成功的状态码HttpServletResponse.SC_OK。 <br>
HTTP头部(HTTP Header)：它们包含了更多关于响应的信息。比如：头部可以指定认为响应过期的过期日期，或者是指定用来给用户安全的传输实体内容的编码格式。如何在Serlet中检索HTTP的头部看这里。 <br>
主体(Body)：它包含了响应的内容。它可以包含HTML代码，图片，等等。主体是由传输在HTTP消息中紧跟在头部后面的数据字节组成的。</p><div class="md-section-divider"></div><h3 data-anchor-id="wuyd" id="什么是cookiesession和cookie有什么区别">什么是cookie？session和cookie有什么区别？</h3><p data-anchor-id="3c5u">cookie是Web服务器发送给浏览器的一块信息。浏览器会在本地文件中给每一个Web服务器存储cookie。以后浏览器在给特定的Web服务器发请求的时候，同时会发送所有为该服务器存储的cookie。下面列出了session和cookie的区别： <br>
无论客户端浏览器做怎么样的设置，session都应该能正常工作。客户端可以选择禁用cookie，但是，session仍然是能够工作的，因为客户端无法禁用服务端的session。 <br>
在存储的数据量方面session和cookies也是不一样的。session能够存储任意的Java对象，cookie只能存储String类型的对象。</p><div class="md-section-divider"></div><h3 data-anchor-id="ckrj" id="sendredirect和forward方法有什么区别">sendRedirect()和forward()方法有什么区别？</h3><p data-anchor-id="jbqx">sendRedirect()方法会创建一个新的请求，而forward()方法只是把请求转发到一个新的目标上。重定向(redirect)以后，之前请求作用域范围以内的对象就失效了，因为会产生一个新的请求，而转发(forwarding)以后，之前请求作用域范围以内的对象还是能访问的。一般认为sendRedirect()比forward()要慢。</p><div class="md-section-divider"></div><h3 data-anchor-id="uog6" id="什么是url编码和url解码">什么是URL编码和URL解码？</h3><p data-anchor-id="w8kh">URL编码是负责把URL里面的空格和其他的特殊字符替换成对应的十六进制表示，反之就是解码。</p><div class="md-section-divider"></div><h3 data-anchor-id="ku59" id="title"> </h3><div class="md-section-divider"></div><h3 data-anchor-id="yu52" id="结束">结束</h3></div>
</body>
</html>